package org.dromara.common.mybatis.core.page;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.Data;
import org.dromara.common.core.exception.ServiceException;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.core.utils.sql.SqlUtil;

import java.io.Serial;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;


/**
 * @Author 刘武贵
 * @Date 2024/8/15 22:00
 * @Description 功能描述：分页查询实体类
 */
@Data
public class PageQuery implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 分页大小
     */
    private Integer pageSize;

    /**
     * 当前页数
     */
    private Integer pageNum;

    /**
     * 排序列
     */
    private String orderByColumn;

    /**
     * 排序的方向desc或者asc
     */
    private String isAsc;

    /**
     * 当前记录起始索引 默认值
     */
    public static final int DEFAULT_PAGE_NUM = 1;

    /**
     * 每页显示记录数 默认值 默认查全部
     */
    public static final int DEFAULT_PAGE_SIZE = Integer.MAX_VALUE;

    /**
     * 构建分页对象
     *
     * @param <T> 泛型参数，表示分页数据的类型
     * @return 返回构建的分页对象
     */
    public <T> Page<T> build() {
        // 获取并确保页码不为空，如果为空则使用默认页码
        Integer pageNum = ObjectUtil.defaultIfNull(getPageNum(), DEFAULT_PAGE_NUM);
        // 获取并确保页大小不为空，如果为空则使用默认页大小
        Integer pageSize = ObjectUtil.defaultIfNull(getPageSize(), DEFAULT_PAGE_SIZE);

        // 如果页码小于等于0，则重置为默认页码
        if (pageNum <= 0) {
            pageNum = DEFAULT_PAGE_NUM;
        }

        // 创建并返回分页对象
        Page<T> page = new Page<>(pageNum, pageSize);

        // 构建排序项
        List<OrderItem> orderItems = buildOrderItem();
        // 如果排序项不为空，则添加到分页对象中
        if (CollUtil.isNotEmpty(orderItems)) {
            page.addOrder(orderItems);
        }

        return page;
    }

    /**
     * 构建排序
     * 构建排序条件列表
     *
     * 该方法用于根据前端传入的排序字段和类型，构建后端可识别的排序条件列表
     * 首先检查排序字段和类型是否为空或无效，然后对排序字段进行转义和格式转换，
     * 接着处理排序类型的兼容性，最后根据处理后的字段和类型构建排序条件列表
     *
     * 支持的用法如下:
     * {isAsc:"asc",orderByColumn:"id"} order by id asc
     * {isAsc:"asc",orderByColumn:"id,createTime"} order by id asc,create_time asc
     * {isAsc:"desc",orderByColumn:"id,createTime"} order by id desc,create_time desc
     * {isAsc:"asc,desc",orderByColumn:"id,createTime"} order by id asc,create_time desc
     * @return 排序条件列表，如果输入无效返回null，如果处理失败抛出ServiceException
     */
    private List<OrderItem> buildOrderItem() {
        if (StringUtils.isBlank(orderByColumn) || StringUtils.isBlank(isAsc)) {
            return null;
        }

        // 对排序字段进行转义，防止SQL注入，并转换为下划线命名风格
        String orderBy = SqlUtil.escapeOrderBySql(orderByColumn);
        orderBy = StringUtils.toUnderScoreCase(orderBy);

        // 兼容前端排序类型，将前端可能的排序类型转换为后端识别的asc和desc
        isAsc = StringUtils.replaceEach(isAsc, new String[]{"ascending", "descending"}, new String[]{"asc", "desc"});

        // 将排序字段和类型按分隔符拆分成数组
        String[] orderByArr = orderBy.split(StringUtils.SEPARATOR);
        String[] isAscArr = isAsc.split(StringUtils.SEPARATOR);
        // 检查排序类型数组长度是否有效，与排序字段数组长度匹配
        if (isAscArr.length != 1 && isAscArr.length != orderByArr.length) {
            throw new ServiceException("排序参数有误");
        }

        // 创建排序条件列表
        List<OrderItem> list = new ArrayList<>();
        // 每个字段各自排序
        // 遍历排序字段数组，根据每个字段和对应的类型构建排序条件
        for (int i = 0; i < orderByArr.length; i++) {
            String orderByStr = orderByArr[i];
            String isAscStr = isAscArr.length == 1 ? isAscArr[0] : isAscArr[i];
            // 根据排序类型添加升序条件
            if ("asc".equals(isAscStr)) {
                list.add(OrderItem.asc(orderByStr));
            } else if ("desc".equals(isAscStr)) {
                // 根据排序类型添加降序条件
                list.add(OrderItem.desc(orderByStr));
            } else {
                throw new ServiceException("排序参数有误");
            }
        }
        return list;
    }

    public Integer getFirstNum() {
        return (pageNum - 1) * pageSize;
    }

}
